package com.gewei.controller;

import com.alibaba.dubbo.config.annotation.Reference;
import com.gewei.constant.MessageConstant;
import com.gewei.dto.CheckItemTypeDTO;
import com.gewei.entity.PageResult;
import com.gewei.entity.QueryPageBean;
import com.gewei.entity.Result;
import com.gewei.pojo.CheckItem;
import com.gewei.service.CheckItemService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * 预约管理-检查项管理
 */
@Slf4j
@RestController
@RequestMapping("/checkitem")
public class CheckItemController {

    /**
     * Dubbo 远程调用服务
     */
    @Reference
    private CheckItemService checkItemService;

    /**
     * 新增检查项
     *
     * @param checkItem
     * @return
     */
    @RequestMapping("/add")
    public Result add(@RequestBody CheckItem checkItem) {
        log.info("新增检查项，checkItem:{}", checkItem);
        try {
            checkItemService.add(checkItem);
            //  新增检查项成功
            return new Result(true, MessageConstant.ADD_CHECKITEM_SUCCESS);
        } catch (Exception e) {
            //  服务调用失败
            e.printStackTrace();
            //  新增检查项失败
            return new Result(false, MessageConstant.ADD_CHECKITEM_FAIL);
        }
    }

    /**
     * 分页查询检查项
     * 本项目所有分页功能都是基于 ajax 的异步请求来完成的，请求参数和后台响应数据格式都使用 JSON 数据格式。
     * 请求参数包括当前页码、每页显示记录数、查询条件。
     * 请求参数的 JSON 格式为：{currentPage:1, pageSize:10, queryString:"体重"}
     * 后台响应数据包括：总记录数、当前页需要展示的数据集合。
     * 响应数据的 JSON 格式为：{total:1000, rows:[]}
     * TODO  权限校验
     *
     * @param queryPageBean
     * @return
     */
    @RequestMapping("/findPage")
    public PageResult findPage(@RequestBody QueryPageBean queryPageBean) {
        log.info("分页查询检查项");
        //  分页查询条件参数检查-前端传参判断
        queryPageBean.checkParam();
        PageResult pageResult = null;
        try {
            pageResult = checkItemService.pageQuery(queryPageBean);
            return pageResult;
        } catch (Exception e) {
            e.printStackTrace();
            //  服务调用失败
            return null;
        }
    }

    /**
     * 根据 ID 删除检查项
     *
     * @param id 检查项 ID
     * @return 操作结果
     */
    @PreAuthorize("hasAuthority('CHECKITEM_DELETE')")
    @RequestMapping("/delete")
    public Result delete(Integer id) {
        log.info("删除检查项，id:{}", id);
        try {
            checkItemService.deleteById(id);
            log.info("删除检查项成功，id:{}", id);
            //  删除检查项成功
            return new Result(true, MessageConstant.DELETE_CHECKITEM_SUCCESS);
        } catch (RuntimeException e) {
//            e.printStackTrace();
            return new Result(false, e.getMessage());
        } catch (Exception e) {
            //  其他异常
            e.printStackTrace();
            log.error("删除检查项失败，id:{}", id, e);
            //  服务调用失败
            return new Result(false, MessageConstant.DELETE_CHECKITEM_FAIL);
        }
    }

    /**
     * 编辑检查项
     *
     * @param checkItem
     * @return
     */
    @RequestMapping("/edit")
    public Result edit(@RequestBody CheckItem checkItem) {
        log.info("编辑检查项，checkItem:{}", checkItem);
        try {
            checkItemService.edit(checkItem);
            //  编辑检查项服务调用成功
            return new Result(true, MessageConstant.EDIT_CHECKITEM_SUCCESS);
        } catch (Exception e) {
            e.printStackTrace();
            //  编辑检查项服务调用失败
            return new Result(false, MessageConstant.EDIT_CHECKITEM_FAIL);
        }
    }

    /**
     * 通过开关组件切换检查项类型
     *
     * @param checkItemTypeDTO 检查项类型 DTO
     * @return
     */
    @RequestMapping("/editType")
    public Result editType(@RequestBody CheckItemTypeDTO checkItemTypeDTO) {
        System.out.println(checkItemTypeDTO.getId());
        try {
            checkItemService.editType(checkItemTypeDTO);
            //  编辑检查项类型成功
            return new Result(true, MessageConstant.EDIT_CHECKITEM_TYPE_SUCCESS);
        } catch (Exception e) {
            e.printStackTrace();
            //  服务调用失败
            return new Result(false, MessageConstant.EDIT_CHECKITEM_TYPE_FAIL);
        }
    }

    /**
     * 查询检查项
     *
     * @param id
     * @return
     */
    @RequestMapping("/findById")
    public Result findById(Integer id) {
        CheckItem checkItem = null;
        try {
            checkItem = checkItemService.findById(id);
            //  查询检查项成功
            return new Result(true, MessageConstant.QUERY_CHECKITEM_SUCCESS, checkItem);
        } catch (Exception e) {
            e.printStackTrace();
            //  服务调用失败
            return new Result(false, MessageConstant.QUERY_CHECKITEM_FAIL);
        }
    }

    /**
     * 查询所有检查项
     *
     * @return
     */
    @RequestMapping("/findAll")
    public Result findAll() {
        try {
            List<CheckItem> checkItemList = checkItemService.findAll();
            //  查询所有检查项成功
            return new Result(true, MessageConstant.QUERY_CHECKITEMS_SUCCESS, checkItemList);
        } catch (Exception e) {
            //  使用日志记录异常
            //log.error("Query check items failed", e);
            //  TODO 使用 e.printStackTrace() 不够规范，建议使用日志框架（如 SLF4J）记录异常。
            e.printStackTrace();
            //  服务调用失败
            return new Result(false, MessageConstant.QUERY_CHECKITEMS_FAIL);
        }
    }
}